package com.cskaoyan.service.impl;


import com.cskaoyan.bean.data.PageData;
import com.cskaoyan.bean.vo.OrderCommentParameter;
import com.cskaoyan.bean.data.OrderDetailData;
import com.cskaoyan.bean.data.OrderListData;
import com.cskaoyan.bean.data.UserIndexData;
import com.cskaoyan.config.ShipConfig;
import com.cskaoyan.mapper.*;
import com.cskaoyan.model.*;
import com.cskaoyan.service.AfterSaleService;
import com.cskaoyan.service.CartService;
import com.cskaoyan.service.OrderService;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    MarketOrderMapper orderMapper;
    @Autowired
    CartService cartService;
    @Autowired
    MarketCartMapper cartMapper;
    @Autowired
    MarketOrderGoodsMapper orderGoodsMapper;
    @Autowired
    MarketGoodsProductMapper goodsProductMapper;
    @Autowired
    MarketCouponUserMapper couponUserMapper;
    @Autowired
    ShipConfig shipConfig;
    @Autowired
    MarketCommentMapper commentMapper;

    @Transactional
    @Override
    public Map submit(int userId, Map<String, Object> parameterMap) {
        /*需要返回的响应字段：
         * grouponLinkId (现阶段不考虑团购，先给值0)
         * orderId 订单id
         * */

        // 创建一个map用于存储响应数据
        Map<String, Object> map = new HashMap<>();
        // 调用cartService的checkout方法，将购物车结账信息重新计算一次
        Map checkoutMap = cartService.checkout(userId, parameterMap);
        // 从上面方法返回的checkoutMap中获得选中的address信息
        MarketAddress address = (MarketAddress) checkoutMap.get("checkedAddress");
        // 获得当前日期时间
        Date date = new Date();
        String dateTimeType = new SimpleDateFormat("yyyyMMdd").format(date) + String.format("%03d", userId) + String.format("%03d", (int) (Math.random() * 100 + 1));
        // 创建一个order用于添加order表记录
        // 而且order的大多数字段都可以从checkoutMap中获得
        MarketOrder order = MarketOrder.builder()
                .userId(userId)
                // 此处的订单编号为 当前时间(年月日)占8位 + 当前用户id占3位 + 随机数(1-100)占3位 共14位
                .orderSn(dateTimeType)
                .orderStatus((short) 101)
                .consignee(address.getName())
                .mobile(address.getTel())
                .address(address.getProvince() + address.getCity() + address.getCounty() + address.getAddressDetail())
                .message(parameterMap.get("message").toString())
                .goodsPrice((BigDecimal) checkoutMap.get("goodsTotalPrice"))
                .freightPrice((BigDecimal) checkoutMap.get("freightPrice"))
                .couponPrice((BigDecimal) checkoutMap.get("couponPrice"))
                .integralPrice(new BigDecimal(0))
                .grouponPrice(new BigDecimal((Integer) checkoutMap.get("grouponPrice")))
                .orderPrice((BigDecimal) checkoutMap.get("orderTotalPrice"))
                .actualPrice((BigDecimal) checkoutMap.get("actualPrice"))
                .addTime(date)
                .updateTime(date)
                .deleted(false)
                .build();


        // 添加order记录
        orderMapper.insertSelective(order);

        MarketOrderExample orderExample = new MarketOrderExample();
        orderExample.createCriteria().andDeletedEqualTo(false).andOrderSnEqualTo(dateTimeType);
        List<MarketOrder> marketOrders = orderMapper.selectByExample(orderExample);
        MarketOrder marketOrder = marketOrders.get(0);


        // 创建cartExample用于查询选中的购物车记录
        MarketCartExample cartExample = new MarketCartExample();
        // 添加查询条件
        cartExample.createCriteria().andUserIdEqualTo(userId)
                .andCheckedEqualTo(true)
                .andDeletedEqualTo(false);
        // 条件查询，得到选中的购物车记录列表
        List<MarketCart> marketCarts = cartMapper.selectByExample(cartExample);
        // 遍历选中的购物车记录，添加orderGoods表记录，同时更新库存
        for (MarketCart marketCart : marketCarts) {
            // 创建orderGoods用于添加记录
            // 这里的大多数字段可以从cart中获得
            MarketOrderGoods orderGoods = MarketOrderGoods.builder()
                    .orderId(order.getId())
                    .goodsId(marketCart.getGoodsId())
                    .goodsName(marketCart.getGoodsName())
                    .goodsSn(marketCart.getGoodsSn())
                    .productId(marketCart.getProductId())
                    .number(marketCart.getNumber())
                    .price(marketCart.getPrice())
                    .specifications(marketCart.getSpecifications())
                    .picUrl(marketCart.getPicUrl())
                    .addTime(date)
                    .updateTime(date)
                    .deleted(false).build();
            // 添加orderGoods记录
            orderGoodsMapper.insertSelective(orderGoods);
            // 通过主键(productId)查询商品的库存量
            Integer productNumber = goodsProductMapper.selectByPrimaryKey(marketCart.getProductId()).getNumber();
            // 得到购物车中要买的商品数量
            Short cartNumber = marketCart.getNumber();
            // 判断库存够不够
            if (productNumber < cartNumber) {
                // 库存不足返回null值，向前端报(711)库存不足
                return null;
            }
            // 库存够的话就更新
            // 创建goodsProduct用于更新库存
            MarketGoodsProduct goodsProduct = MarketGoodsProduct.builder().id(marketCart.getProductId()).number(productNumber - cartNumber).updateTime(date).build();
            // 通过主键选择性更新库存
            goodsProductMapper.updateByPrimaryKeySelective(goodsProduct);
        }
        // 创建marketCart用于删除购物车记录
        MarketCart marketCart = MarketCart.builder().deleted(true)
                .updateTime(date)
                .build();
        // 逻辑删除，条件还是上面查询选中购物车记录的条件(因为要删的就是查出的记录，所以条件一样)
        cartMapper.updateByExampleSelective(marketCart, cartExample);
        // 得到userCouponId
        Integer userCouponId = Integer.parseInt(checkoutMap.get("userCouponId").toString());
        // 如果userCouponId不为0说明使用了优惠劵
        if (userCouponId > 0) {
            // 创建couponUser用于修改优惠劵状态
            MarketCouponUser couponUser = couponUserMapper.selectByPrimaryKey(userCouponId);
            couponUser.setUpdateTime(new Date());
            couponUser.setStatus((short) 1);
            couponUser.setOrderId(marketOrder.getId());
            couponUser.setUsedTime(new Date());
            // 通过主键(userCouponId)修改优惠劵状态为已使用
            couponUserMapper.updateByPrimaryKeySelective(couponUser);
        }
        // 现阶段不考虑团购
        map.put("grouponLinkId", parameterMap.get("grouponLinkId"));
        // 添加响应字段orderId到响应map
        map.put("orderId", order.getId());
        // 返回响应数据
        return map;
    }

    @Override
    public PageData list(Integer userId, Integer page, Integer limit, Integer showType) {
        /*前端需要的响应数据是一个list，list中封装了如下数据
         * actualPrice 实付费用
         * aftersaleStatus 售后状态
         * goodsList 商品列表
         * handleOption 关于前端要显示哪些按钮，其中字段的值为true就显示该按钮，默认都为false
         * id 订单id
         * isGroupin 是否团购
         * orderSn 订单编号
         * orderStatusText 订单状态信息
         *  */
        // 创建dataList用于封装数据 其中OrderListData就是包含上述字段的一个类
        List<OrderListData> dataList = new ArrayList<>();
        // 创建一个example用于查询订单列表
        MarketOrderExample example = new MarketOrderExample();
        example.setOrderByClause("add_time desc");
        MarketOrderExample.Criteria criteria = example.createCriteria().andDeletedEqualTo(false)
                .andUserIdEqualTo(userId);
        if (showType == 1) {
            criteria.andOrderStatusEqualTo((short) 101);
        } else if (showType == 2) {
            criteria.andOrderStatusEqualTo((short) 201);
        } else if (showType == 3) {
            criteria.andOrderStatusEqualTo((short) 301);
        } else if (showType == 4) {
            Short[] orderStatus = new Short[]{401, 402};
            criteria.andOrderStatusIn(Arrays.asList(orderStatus));
        }
        // 开始分页
        PageHelper.startPage(page, limit);
        // 根据隐含条件userId查询订单表
        List<MarketOrder> orderList = orderMapper.selectByExample(example);
        PageData pageData = PageData.list(orderList);
        // 遍历orderList，向dataList中添加数据
        for (MarketOrder order : orderList) {
            // 创建data用于封装数据，最后加到dataList表中
            OrderListData data = new OrderListData();
            // 获得订单状态
            Short orderStatus = order.getOrderStatus();
            // 创建handleOption，其中的字段状态值与前端显示哪些按钮有关
            OrderListData.HandleOption handleOption = new OrderListData.HandleOption();
            if (orderStatus.intValue() == 101) {
                // 如果订单状态为未付款
                // 设置订单状态信息为 待付款
                data.setOrderStatusText("待付款");
                // 添加去支付按钮
                handleOption.setPay(true);
                // 添加取消订单按钮
                handleOption.setCancel(true);
            } else if (orderStatus.intValue() == 201) {
                // 订单状态为已付款
                // 设置订单状态信息为 已付款
                data.setOrderStatusText("已付款");
                // 添加申请退款按钮
                handleOption.setRefund(true);
//                handleOption.setCancel(true);
            } else if (orderStatus.intValue() == 202) {
                // 如果订单状态为申请退款
                // 设置订单状态信息为 订单取消，退款中
                // 此时订单不显示任何按钮
                data.setOrderStatusText("订单取消，退款中");
            } else if (orderStatus.intValue() == 203) {
                // 订单状态为已退款
                // 设置订单状态信息为 已退款
                data.setOrderStatusText("已退款");
                // 添加删除订单按钮
                handleOption.setDelete(true);
            } else if (orderStatus.intValue() == 301) {
                // 订单状态为已发货
                // 设置订单状态为 已发货
                data.setOrderStatusText("已发货");
                // 添加确认收货按钮
                handleOption.setConfirm(true);
            } else if (orderStatus.intValue() == 401 || orderStatus.intValue() == 402) {
                // 订单状态为用户收货(401)或系统收货(402)
                // 设置订单状态信息为 已收货
                data.setOrderStatusText("已收货");
                if (order.getComments() > 0) {
                    // 如果comments字段值为0 说明可以评论
                    // 添加去评论按钮
                    handleOption.setComment(true);
                }
                // 添加删除订单按钮
                handleOption.setDelete(true);
                // 添加再次购买按钮
                handleOption.setRebuy(true);
                //添加申请售后按钮
                handleOption.setAftersale(true);
            } else {
                // 其余订单状态 用户取消(102)、系统取消(103)
                // 设置订单状态信息为 已取消
                data.setOrderStatusText("已取消");
                // 添加删除订单按钮
                handleOption.setDelete(true);
            }
            // 给data中的其余字段赋值(可以从order中获得这些字段)
            data.setAftersaleStatus(order.getAftersaleStatus());
            data.setOrderSn(order.getOrderSn());
            data.setActualPrice(order.getActualPrice());
            data.setId(order.getId());
            // 设置handleOption给前端显示按钮用
            data.setHandleOption(handleOption);
            // 创建goodsList封装商品信息
            List<OrderListData.GoodsList> goodsList = new ArrayList<>();
            // 创建goodsExample用于查询orderGoods表中信息
            MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
            // 添加查询条件
            goodsExample.createCriteria().andDeletedEqualTo(false)
                    .andOrderIdEqualTo(order.getId());
            // 通过订单id得到商品信息表
            List<MarketOrderGoods> orderGoods = orderGoodsMapper.selectByExample(goodsExample);
            // 遍历orderGoods，给goodsList添加数据
            for (MarketOrderGoods orderGood : orderGoods) {
                // 创建goods封装单条记录
                OrderListData.GoodsList goods = new OrderListData.GoodsList();
                // 从orderGood中copy信息(goods中的所有字段都可以在orderGood中找到)
                BeanUtils.copyProperties(orderGood, goods);
                // 添加单条记录到信息表中
                goodsList.add(goods);
            }
            // 封装goodsList
            data.setGoodsList(goodsList);
            // 将单个data添加到dataList
            dataList.add(data);
        }
        // 其他值(showType为0)，则返回全部data(在前端“全部”下显示的数据)
        pageData.setList(dataList);
        return pageData;
    }

    @Override
    public OrderDetailData detail(Integer orderId) {
        /*前端需要的响应字段：
         * expressInfo 物流详细信息，先返回空表
         * orderGoods 商品信息表
         * orderInfo 订单信息
         * */
        // 创建data用于封装订单详情信息(也就是上面的响应字段)
        OrderDetailData data = new OrderDetailData();
        // 创建goodsExample用于查询商品信息
        MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
        // 添加条件
        goodsExample.createCriteria().andOrderIdEqualTo(orderId)
                .andDeletedEqualTo(false);
        // 根据条件查询出商品信息表
        List<MarketOrderGoods> orderGoods = orderGoodsMapper.selectByExample(goodsExample);
        // 封装订单商品信息
        data.setOrderGoods(orderGoods);
        // 通过主键(orderId)获得订单记录
        MarketOrder order = orderMapper.selectByPrimaryKey(orderId);
        // 创建orderInfo用于封装订单信息
        OrderDetailData.OrderInfo orderInfo = new OrderDetailData.OrderInfo();
        // 从order中获得orderInfo中需要的字段(copy)
        BeanUtils.copyProperties(order, orderInfo);
        // 得到订单状态，后续做判断
        Short orderStatus = order.getOrderStatus();
        // 和上面order/list中的handleOption如出一辙，也是给前端显示哪些按钮用的
        OrderDetailData.OrderInfo.HandleOption handleOption = new OrderDetailData.OrderInfo.HandleOption();
        // 判断订单状态，封装订单状态信息并根据条件添加某个/些按钮
        if (orderStatus == 101) {
            // 如果订单状态为未付款
            // 设置订单状态信息为 待付款
            orderInfo.setOrderStatusText("待付款");
            // 添加去支付按钮
            handleOption.setPay(true);
            // 添加取消订单按钮
            handleOption.setCancel(true);
        } else if (orderStatus == 201) {
            // 订单状态为已付款
            // 设置订单状态信息为 已付款
            orderInfo.setOrderStatusText("已付款");
            // 添加申请退款按钮
            handleOption.setRefund(true);
//                handleOption.setCancel(true);
        } else if (orderStatus == 202) {
            // 如果订单状态为申请退款
            // 设置订单状态信息为 订单取消，退款中
            // 此时订单不显示任何按钮
            orderInfo.setOrderStatusText("订单取消，退款中");
        } else if (orderStatus == 203) {
            // 订单状态为已退款
            // 设置订单状态信息为 已退款
            orderInfo.setOrderStatusText("已退款");
            // 添加删除订单按钮
            handleOption.setDelete(true);
        } else if (orderStatus == 301) {
            // 订单状态为已发货
            // 设置订单状态为 已发货
            orderInfo.setOrderStatusText("已发货");
            // 添加确认收货按钮
            handleOption.setConfirm(true);
        } else if (orderStatus == 401 || orderStatus == 402) {
            // 订单状态为用户收货(401)或系统收货(402)
            // 设置订单状态信息为 已收货
            orderInfo.setOrderStatusText("已收货");
            if (order.getComments() > 0) {
                // 如果comments字段值为0 说明可以评论
                // 添加去评论按钮
                handleOption.setComment(true);
            }
            // 添加删除订单按钮
            handleOption.setDelete(true);
            // 添加再次购买按钮
            handleOption.setRebuy(true);
            // 添加申请售后按钮
            handleOption.setAftersale(true);
        } else {
            // 其余订单状态 用户取消(102)、系统取消(103)
            // 设置订单状态信息为 已取消
            orderInfo.setOrderStatusText("已取消");
            // 添加删除订单按钮
            handleOption.setDelete(true);
        }
        // 封装handleOption
        orderInfo.setHandleOption(handleOption);
        if (orderStatus == 301 || orderStatus == 401 || orderStatus == 402) {
            // 如果订单状态为 已发货(301)、用户收货(401)、系统收货(402)，则要添加物流信息
            // 下面注释掉的是老方法，通过ship.properties配置文件来添加物流信息
            /*orderInfo.setExpCode(order.getShipChannel());
            orderInfo.setExpNo(order.getShipSn());
            Properties properties = new Properties();
            InputStream inputStream = OrderServiceImpl.class.getClassLoader().getResourceAsStream("ship.properties");
            try {
                properties.load(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            orderInfo.setExpName(properties.getProperty(order.getShipChannel()));*/
            // 封装expCode(发货快递公司)
            orderInfo.setExpCode(order.getShipChannel());
            // 封装expNo(快递编号)
            orderInfo.setExpNo(order.getShipSn());
            // 下面通过反射来获取expName(快递公司名称)
            // ShipConfig是封装了快递公司简称与快递公司名称对应关系的一个类(比如：其中的成员变量ZTO 它的值就是中通快递)
            // 获取字节码文件对象
            Class<? extends ShipConfig> shipConfigClass = ShipConfig.class;
            // 通过字节码文件对象获得所有成员变量
            Field[] fields = shipConfigClass.getDeclaredFields();
            // 防止由于成员变量的权限为private而导致访问失败报异常，这里直接暴力打开
            Field.setAccessible(fields, true);
            // 遍历判断
            for (Field field : fields) {
                // 得到成员变量名称
                String fieldName = field.getName();
                // 进行判断
                if (fieldName.equals(order.getShipChannel())) {
                    // 如果成员变量名称和订单的快递公司简称相同
                    try {
                        // 对expName(快递公司全称)赋值，成员变量的值就是快递公司全称
                        orderInfo.setExpName((String) field.get(shipConfig));
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
        // 封装订单信息
        data.setOrderInfo(orderInfo);
        // 返回响应数据
        return data;
    }

    @Override
    public void refund(Integer orderId) {
        /*返回给前端的响应报文中没有额外数据，这里只需要进行订单退款的处理即可，不返回数据
         * */
//        MarketOrder order = orderMapper.selectByPrimaryKey(orderId);
//        order.setUpdateTime(new Date());
//        order.setOrderStatus((short) 202);
        // 创建order主要用于更新订单状态
        MarketOrder order = MarketOrder.builder().updateTime(new Date())
                // 订单状态202表示申请退款
                .orderStatus((short) 202)
                .id(orderId)
                .build();
        /*//创建goodsExample用于查询商品信息
        MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
        //添加条件
        goodsExample.createCriteria().andOrderIdEqualTo(orderId)
                .andDeletedEqualTo(false);
        //选择性查询，得到商品信息列表
        List<MarketOrderGoods> goodsList = orderGoodsMapper.selectByExample(goodsExample);
        //遍历商品信息列表，增加库存
        for (MarketOrderGoods goods : goodsList) {
            Integer productId = goods.getProductId();
            Short number = goods.getNumber();
            MarketGoodsProduct product = goodsProductMapper.selectByPrimaryKey(productId);
            product.setNumber(product.getNumber() + number);
            goodsProductMapper.updateByPrimaryKeySelective(product);
        }*/
        // 更新订单信息
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public void cancel(Integer orderId) {
        /*返回给前端的响应报文中没有额外数据，这里只需要进行取消订单的处理即可，不返回数据
         * */
        MarketOrder order = orderMapper.selectByPrimaryKey(orderId);
        order.setUpdateTime(new Date());
        // 判断订单状态
        if (order.getOrderStatus() == 101) {
            // 如果订单状态是未付款(101)，则改为 用户取消(102)
            order.setOrderStatus((short) 102);
        }
        if (order.getOrderStatus() == 201) {
            // 如果订单状态是已付款(201)，则改为 申请退款(202)
            order.setOrderStatus((short) 202);
        }
        // 更新订单信息
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public void delete(Integer orderId) {
        /*返回给前端的响应报文中没有额外数据，这里只需要进行删除订单的处理即可，不返回数据
         * */
        // 创建goodsExample用于查询商品信息
        MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
        // 添加条件
        goodsExample.createCriteria().andDeletedEqualTo(false)
                .andOrderIdEqualTo(orderId);
        // 条件查询得到商品信息列表
        List<MarketOrderGoods> goodsList = orderGoodsMapper.selectByExample(goodsExample);
        // 获得当前日期时间
        Date date = new Date();
        // 遍历商品列表，更新字段，有评论的删除评论
        for (MarketOrderGoods goods : goodsList) {
            // 设置deleted为true
            goods.setDeleted(true);
            // 更新时间
            goods.setUpdateTime(date);
            // 逻辑删除(market_order_goods表)
            orderGoodsMapper.updateByPrimaryKeySelective(goods);
            // 判断comment字段
            if (goods.getComment() > 0) {
                // 如果comment>0，则该字段值为commentId(market_comment表主键)
                // 创建comment用于删除此订单商品的评论
                MarketComment comment = MarketComment.builder().updateTime(date)
                        .id(goods.getComment())
                        .deleted(true).build();
                // 逻辑删除(market_comment表)
                commentMapper.updateByPrimaryKeySelective(comment);
            }
        }
        // 创建order用于删除此订单记录
        MarketOrder order = MarketOrder.builder().updateTime(date)
                .deleted(true)
                .id(orderId)
                .build();
        // 逻辑删除(market_order表)
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public void confirm(Integer orderId) {
        /*返回给前端的响应报文中没有额外数据，这里只需要进行确认收货的处理即可，不返回数据
         * */
        // 创建goodsExample用于查找订单商品信息
        MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
        // 添加查询条件
        goodsExample.createCriteria().andOrderIdEqualTo(orderId)
                .andDeletedEqualTo(false);
        // 查询得到orderGoods列表
        List<MarketOrderGoods> orderGoods = orderGoodsMapper.selectByExample(goodsExample);
        // 通过流得到商品总数(用来修改order的comments字段)
        int sum = orderGoods.stream().mapToInt(MarketOrderGoods::getNumber).sum();
        // 创建order主要用于更新订单状态
        MarketOrder order = MarketOrder.builder().updateTime(new Date())
                // 401代表用户收货
                .orderStatus((short) 401)
                .id(orderId)
                // 更新订单的待评价商品数量(comments字段)
                .comments((short) sum)
                .build();
        // 选择性更新
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public MarketOrderGoods goods(Integer orderId, Integer goodsId) {
        /*需要返回的响应字段可以用MarketOrderGoods这个类来封装，所以此方法返回一个该类型的对象
         *  */
        // 创建goodsExample用于查找商品信息
        MarketOrderGoodsExample goodsExample = new MarketOrderGoodsExample();
        // 添加查询条件
        goodsExample.createCriteria().andDeletedEqualTo(false)
                .andOrderIdEqualTo(orderId)
                .andGoodsIdEqualTo(goodsId);
        // 通过查询得到商品信息列表(实际上表中应该只有一条记录)
        List<MarketOrderGoods> orderGoods = orderGoodsMapper.selectByExample(goodsExample);
        // 为了保证代码健壮性，返回的时候做一下判断
        return orderGoods != null && orderGoods.size() == 1 ? orderGoods.get(0) : null;
    }

    @Override
    public void comment(OrderCommentParameter parameter, int userId) {
        /*返回给前端的响应报文中没有额外数据，这里只需要进行商品评价的相关处理即可，不返回数据
         * */
        // 通过主键(orderGoodsId)查询得到评价的商品信息
        MarketOrderGoods orderGoods = orderGoodsMapper.selectByPrimaryKey(parameter.getOrderGoodsId());
        // 获取当前日期时间
        Date date = new Date();
        // 创建comment用于添加商品评论(market_comment表)
        MarketComment comment = MarketComment.builder()
                // type为0时valueId表示商品id
                .valueId(orderGoods.getGoodsId())
                .type((byte) 0)
                .userId(userId)
                .addTime(date)
                .updateTime(date)
                .deleted(false)
                .build();
        // 将前端传来的评论信息copy到comment对象中
        BeanUtils.copyProperties(parameter, comment);
        // 添加商品评论信息
        commentMapper.insertSelective(comment);
        // 修改商品信息的comment字段为评论表中的该商品评论id
        orderGoods.setComment(comment.getId());
        // 更新时间
        orderGoods.setUpdateTime(date);
        // 选择性更新(market_order_goods表)
        orderGoodsMapper.updateByPrimaryKeySelective(orderGoods);
        // 得到orderId(market_order表的主键)
        Integer orderId = orderGoods.getOrderId();
        // 通过主键查到此商品的订单记录
        MarketOrder order = orderMapper.selectByPrimaryKey(orderId);
        // 修改order的comments字段(减少待评价商品数量)
        order.setComments((short) (order.getComments() - orderGoods.getNumber()));
        // 更新时间
        order.setUpdateTime(date);
        // 选择性更新(market_order表)
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public void prepay(Integer orderId) {
        // 创建order，更新订单状态，这里只是简单做的处理，所以没有更新表中的 pay_id 和 pay_time 字段
        MarketOrder order = MarketOrder.builder().updateTime(new Date())
                .orderStatus((short) 201)
                .id(orderId)
                .build();
        // 通过orderId(主键)选择性更新
        orderMapper.updateByPrimaryKeySelective(order);
    }

    @Override
    public UserIndexData userIndex(Integer userId) {
        // 1. 根据userId查询订单表的记录
        MarketOrderExample example = new MarketOrderExample();
//        example.createCriteria().andDeletedEqualTo(false)
//                .andUserIdEqualTo(userId);
//        List<MarketOrder> marketOrders = orderMapper.selectByExample(example);

        // 2. 查询data数据中的order中的四个字段的信息
        // 2.1 查询未评论的订单
        long uncomment = 0;
        example.clear();
        example.createCriteria().andDeletedEqualTo(false)
                .andOrderStatusIn(Arrays.asList((short) 401, (short) 402))
                .andUserIdEqualTo(userId);
        List<MarketOrder> marketOrders = orderMapper.selectByExample(example);
        List<Integer> orderIdList = marketOrders.stream().map(MarketOrder::getId).collect(Collectors.toList());

        MarketOrderGoodsExample example1 = new MarketOrderGoodsExample();
        MarketOrderGoodsExample.Criteria criteria = example1.createCriteria().andDeletedEqualTo(false)
                .andCommentEqualTo(0);
        if (orderIdList != null && !orderIdList.isEmpty()) {
            criteria.andOrderIdIn(orderIdList);
            uncomment = orderGoodsMapper.countByExample(example1);
        }

        // 2.2 查询未支付的订单
        example.clear();
        example.createCriteria().andDeletedEqualTo(false)
                .andOrderStatusEqualTo((short) 101)
                .andUserIdEqualTo(userId);
        long unpaid = orderMapper.countByExample(example);

        // 2.3 查询未收货的订单
        example.clear();
        example.createCriteria().andDeletedEqualTo(false)
                .andOrderStatusEqualTo((short) 301)
                .andUserIdEqualTo(userId);
        long unrecv = orderMapper.countByExample(example);

        // 2.4 查询未发货的订单
        example.clear();
        example.createCriteria().andDeletedEqualTo(false)
                .andOrderStatusEqualTo((short) 201)
                .andUserIdEqualTo(userId);
        long unship = orderMapper.countByExample(example);

        // 3. 将上述信息封装到data中的order中
        UserIndexData.OrderDTO order = UserIndexData.OrderDTO.builder()
                .unpaid(unpaid)
                .unrecv(unrecv)
                .uncomment(uncomment)
                .unship(unship)
                .build();
        // 4. 将order封装到UserIndexData对象中
        UserIndexData data = UserIndexData.builder()
                .order(order)
                .build();

        return data;
    }

    @Override
    public MarketOrder findById(Integer orderId) {
        MarketOrderExample example = new MarketOrderExample();
        example.createCriteria().andIdEqualTo(orderId)
                .andDeletedEqualTo(false);
        List<MarketOrder> orderList = orderMapper.selectByExample(example);
        return orderList != null && orderList.size() == 1 ? orderList.get(0) : null;
    }

    @Override
    public int updateAftersaleStatus(Integer orderId) {
        MarketOrderExample example = new MarketOrderExample();
        example.createCriteria().andIdEqualTo(orderId)
                .andDeletedEqualTo(false);

        MarketOrder record = MarketOrder.builder()
                .aftersaleStatus((short) 1)
                .build();
        return orderMapper.updateByExampleSelective(record, example);
    }
}
